import React, { useState, useEffect } from "react";
import {
  Card,
  Row,
  Col,
  Statistic,
  Table,
  Progress,
  Tag,
  Typography,
  Space,
  Button,
  Select,
  DatePicker,
  Alert,
  List,
  Avatar,
  Tooltip,
  Badge,
  Divider,
  Tabs,
  message,
  Empty,
  Spin,
  Timeline,
  Modal,
  Descriptions,
  Steps,
  Collapse,
  Rate,
} from "antd";
import {
  UserOutlined,
  TeamOutlined,
  BookOutlined,
  TrophyOutlined,
  RiseOutlined,
  FallOutlined,
  ClockCircleOutlined,
  FireOutlined,
  EyeOutlined,
  DownloadOutlined,
  PrinterOutlined,
  ReloadOutlined,
  WarningOutlined,
  CheckCircleOutlined,
  ExclamationCircleOutlined,
  StarOutlined,
  GlobalOutlined,
  DashboardOutlined,
  BellOutlined,
  RobotOutlined,
  SyncOutlined,
  LoadingOutlined,
  BarChartOutlined,
  LineChartOutlined,
  PieChartOutlined,
  BulbOutlined,
  BookOutlined as BookIcon,
  CalendarOutlined,
  CheckCircleFilled,
  CloseCircleFilled,
  ExclamationCircleFilled,
  InfoCircleFilled,
} from "@ant-design/icons";
import {
  BarChart,
  Bar,
  XAxis,
  YAxis,
  CartesianGrid,
  Tooltip as RechartsTooltip,
  Legend,
  LineChart,
  Line,
  PieChart,
  Pie,
  Cell,
  ResponsiveContainer,
  AreaChart,
  Area,
  RadarChart,
  PolarGrid,
  PolarAngleAxis,
  PolarRadiusAxis,
  Radar,
} from "recharts";
import styled from "styled-components";
import dayjs from "dayjs";
import relativeTime from "dayjs/plugin/relativeTime";
import { useUser } from "../../../contexts/UserContext";

dayjs.extend(relativeTime);

const { Title, Text, Paragraph } = Typography;
const { RangePicker } = DatePicker;
const { Option } = Select;
const { TabPane } = Tabs;
const { Step } = Steps;
const { Panel } = Collapse;

// 类型定义
interface CourseScore {
  id: string;
  courseName: string;
  teacherName: string;
  credit: number;
  semester: string;
  attendance: number;
  homework: {
    total: number;
    submitted: number;
    averageScore: number;
  };
  exams: {
    total: number;
    completed: number;
    averageScore: number;
    ranking: number;
  };
  overallScore: number;
  grade: string;
  trend: "up" | "down" | "stable";
}

interface LearningStatus {
  totalCourses: number;
  averageScore: number;
  attendanceRate: number;
  homeworkCompletionRate: number;
  examPassRate: number;
  studyTime: number;
  ranking: number;
  improvement: number;
}

interface AIAnalysisResult {
  id: string;
  timestamp: Date;
  courseId?: string;
  analysisType: "overall" | "course_specific";
  summary: string;
  keyFindings: string[];
  recommendations: string[];
  confidence: number;
  status: "pending" | "processing" | "completed" | "failed";
}

interface AISuggestionResult {
  id: string;
  timestamp: Date;
  courseId?: string;
  suggestionType: "study_plan" | "skill_improvement" | "time_management" | "exam_preparation";
  title: string;
  description: string;
  suggestions: string[];
  priority: "high" | "medium" | "low";
  estimatedTime: string;
  difficulty: number;
  status: "pending" | "processing" | "completed" | "failed";
}

interface KnowledgePoint {
  name: string;
  mastery: number;
  importance: number;
  recentTrend: number[];
  needsImprovement: boolean;
}

const AnalysisContainer = styled.div`
  padding: 24px;
  background: #f5f5f5;
  min-height: 100vh;
`;

const StyledCard = styled(Card)`
  margin-bottom: 24px;
  border-radius: 12px;
  box-shadow: 0 4px 16px rgba(0, 0, 0, 0.1);
  transition: all 0.3s ease;

  &:hover {
    box-shadow: 0 6px 24px rgba(0, 0, 0, 0.15);
    transform: translateY(-2px);
  }

  .ant-card-head {
    border-bottom: 1px solid #f0f0f0;
    background: linear-gradient(135deg, #fafafa 0%, #fff 100%);
    border-radius: 12px 12px 0 0;
  }

  .ant-card-head-title {
    font-weight: 600;
    font-size: 16px;
    color: #262626;
  }
`;

const MetricCard = styled(Card)`
  text-align: center;
  border-radius: 12px;
  background: linear-gradient(135deg, #fff 0%, #fafafa 100%);
  border: 1px solid #f0f0f0;
  transition: all 0.3s ease;

  &:hover {
    transform: translateY(-4px);
    box-shadow: 0 8px 24px rgba(0, 0, 0, 0.12);
  }

  .metric-content {
    padding: 20px;
  }

  .metric-icon {
    font-size: 32px;
    margin-bottom: 12px;
  }

  .metric-value {
    font-size: 28px;
    font-weight: bold;
    color: #262626;
    margin-bottom: 8px;
  }

  .metric-label {
    font-size: 14px;
    color: #8c8c8c;
    margin-bottom: 8px;
  }

  .metric-trend {
    font-size: 12px;
    display: flex;
    align-items: center;
    justify-content: center;
    gap: 4px;
  }
`;

const TrendTag = styled(Tag)`
  border-radius: 6px;
  font-weight: 500;
  padding: 4px 8px;
`;

const AIAnalysisCard = styled(Card)`
  background: linear-gradient(135deg, #f6ffed 0%, #fff 100%);
  border: 1px solid #b7eb8f;
  border-radius: 12px;
  margin-bottom: 16px;

  .ant-card-head {
    background: linear-gradient(135deg, #f6ffed 0%, #fff 100%);
    border-bottom: 1px solid #b7eb8f;
  }

  .ant-card-head-title {
    color: #52c41a;
    font-weight: 600;
  }
`;

const AISuggestionCard = styled(Card)`
  background: linear-gradient(135deg, #fff7e6 0%, #fff 100%);
  border: 1px solid #ffd591;
  border-radius: 12px;
  margin-bottom: 16px;

  .ant-card-head {
    background: linear-gradient(135deg, #fff7e6 0%, #fff 100%);
    border-bottom: 1px solid #ffd591;
  }

  .ant-card-head-title {
    color: #fa8c16;
    font-weight: 600;
  }
`;

const StudentLearningAnalysis: React.FC = () => {
  const { user } = useUser();
  const [loading, setLoading] = useState(false);
  const [analyzing, setAnalyzing] = useState(false);
  const [suggesting, setSuggesting] = useState(false);
  const [selectedCourse, setSelectedCourse] = useState<string>("all");
  const [courseScores, setCourseScores] = useState<CourseScore[]>([]);
  const [learningStatus, setLearningStatus] = useState<LearningStatus>({
    totalCourses: 0,
    averageScore: 0,
    attendanceRate: 0,
    homeworkCompletionRate: 0,
    examPassRate: 0,
    studyTime: 0,
    ranking: 0,
    improvement: 0,
  });
  const [aiAnalysisResults, setAiAnalysisResults] = useState<AIAnalysisResult[]>([]);
  const [aiSuggestionResults, setAiSuggestionResults] = useState<AISuggestionResult[]>([]);
  const [knowledgePoints, setKnowledgePoints] = useState<KnowledgePoint[]>([]);

  // 生成模拟数据
  const generateMockData = () => {
    // 生成课程成绩数据 - 每个课程都有不同的特点和表现
    const mockCourseScores: CourseScore[] = [
      {
        id: "1",
        courseName: "高等数学(一)",
        teacherName: "张教授",
        credit: 4,
        semester: "2024-2025-1",
        attendance: 96, // 数学课出勤率较高
        homework: {
          total: 15, // 数学作业较多
          submitted: 14, // 偶尔会漏交
          averageScore: 82.3, // 数学作业难度较大，分数相对较低
        },
        exams: {
          total: 4, // 数学考试次数较多
          completed: 4,
          averageScore: 79.8, // 数学考试难度大，分数较低
          ranking: 22, // 排名中等偏下
        },
        overallScore: 81.0,
        grade: "B-",
        trend: "down", // 数学成绩有下降趋势
      },
      {
        id: "2",
        courseName: "大学英语(一)",
        teacherName: "李教授",
        credit: 3,
        semester: "2024-2025-1",
        attendance: 88, // 英语课出勤率一般
        homework: {
          total: 10,
          submitted: 9, // 偶尔会漏交作业
          averageScore: 85.6, // 英语作业分数中等
        },
        exams: {
          total: 3,
          completed: 3,
          averageScore: 83.2, // 英语考试分数一般
          ranking: 35, // 排名靠后
        },
        overallScore: 84.4,
        grade: "B",
        trend: "stable", // 英语成绩稳定
      },
      {
        id: "3",
        courseName: "Python程序设计",
        teacherName: "王教授",
        credit: 3,
        semester: "2024-2025-1",
        attendance: 99, // 编程课出勤率最高
        homework: {
          total: 12,
          submitted: 12, // 编程作业全部完成
          averageScore: 96.8, // 编程作业分数很高
        },
        exams: {
          total: 2,
          completed: 2,
          averageScore: 94.5, // 编程考试分数很高
          ranking: 2, // 排名很靠前
        },
        overallScore: 95.7,
        grade: "A+",
        trend: "up", // 编程成绩持续上升
      },
      {
        id: "4",
        courseName: "数据结构与算法",
        teacherName: "陈教授",
        credit: 4,
        semester: "2024-2025-1",
        attendance: 92, // 算法课出勤率较好
        homework: {
          total: 18, // 算法作业最多
          submitted: 16, // 偶尔会漏交
          averageScore: 78.9, // 算法作业难度很大
        },
        exams: {
          total: 3,
          completed: 3,
          averageScore: 75.3, // 算法考试分数较低
          ranking: 28, // 排名靠后
        },
        overallScore: 77.1,
        grade: "C+",
        trend: "down", // 算法成绩下降
      },
      {
        id: "5",
        courseName: "大学物理(一)",
        teacherName: "刘教授",
        credit: 4,
        semester: "2024-2025-1",
        attendance: 94, // 物理课出勤率较好
        homework: {
          total: 14,
          submitted: 13, // 偶尔会漏交
          averageScore: 87.2, // 物理作业分数较好
        },
        exams: {
          total: 3,
          completed: 3,
          averageScore: 84.1, // 物理考试分数中等
          ranking: 16, // 排名中等
        },
        overallScore: 85.7,
        grade: "B+",
        trend: "up", // 物理成绩有上升趋势
      },
      {
        id: "6",
        courseName: "线性代数",
        teacherName: "赵教授",
        credit: 3,
        semester: "2024-2025-1",
        attendance: 90, // 线性代数出勤率一般
        homework: {
          total: 12,
          submitted: 11, // 偶尔会漏交
          averageScore: 80.5, // 线性代数作业分数中等
        },
        exams: {
          total: 2,
          completed: 2,
          averageScore: 77.8, // 线性代数考试分数较低
          ranking: 31, // 排名靠后
        },
        overallScore: 79.2,
        grade: "B-",
        trend: "stable", // 线性代数成绩稳定
      },
    ];

    // 生成学习状态数据 - 基于新的课程数据重新计算
    const mockLearningStatus: LearningStatus = {
      totalCourses: 6, // 增加到6门课程
      averageScore: 83.7, // 重新计算平均分
      attendanceRate: 93.2, // 重新计算出勤率
      homeworkCompletionRate: 91.7, // 重新计算作业完成率
      examPassRate: 100.0,
      studyTime: 45, // 增加学习时间
      ranking: 18, // 调整排名
      improvement: 2.8, // 调整进步幅度
    };

    // 生成知识点数据 - 与课程表现对应
    const mockKnowledgePoints: KnowledgePoint[] = [
      {
        name: "微积分基础",
        mastery: 78, // 对应高等数学成绩下降
        importance: 5,
        recentTrend: [82, 80, 78, 79, 78], // 下降趋势
        needsImprovement: true, // 需要改进
      },
      {
        name: "英语听说",
        mastery: 72, // 对应英语成绩一般
        importance: 4,
        recentTrend: [70, 71, 72, 71, 72], // 稳定但较低
        needsImprovement: true, // 需要改进
      },
      {
        name: "Python编程",
        mastery: 96, // 对应Python课程优秀表现
        importance: 5,
        recentTrend: [92, 94, 96, 95, 96], // 上升趋势
        needsImprovement: false, // 表现优秀
      },
      {
        name: "算法设计",
        mastery: 68, // 对应数据结构与算法成绩较差
        importance: 5,
        recentTrend: [72, 70, 68, 69, 68], // 下降趋势
        needsImprovement: true, // 需要改进
      },
      {
        name: "物理力学",
        mastery: 84, // 对应大学物理成绩较好
        importance: 4,
        recentTrend: [80, 82, 84, 83, 84], // 上升趋势
        needsImprovement: false, // 表现良好
      },
      {
        name: "线性代数",
        mastery: 75, // 对应线性代数成绩一般
        importance: 4,
        recentTrend: [76, 75, 75, 76, 75], // 稳定但较低
        needsImprovement: true, // 需要改进
      },
    ];

    // 生成AI分析结果
    const mockAIAnalysisResults: AIAnalysisResult[] = [
      {
        id: "1",
        timestamp: new Date(Date.now() - 30 * 60 * 1000),
        analysisType: "overall",
        summary: "整体学习表现良好，在编程类课程中表现突出，但在英语听说和算法设计方面需要加强",
        keyFindings: [
          "Python程序设计课程表现优秀，排名第3",
          "英语听说能力有待提升，建议增加练习",
          "算法设计课程需要更多练习和复习",
          "出勤率良好，学习态度积极"
        ],
        recommendations: [
          "增加英语听说练习时间",
          "加强算法设计练习",
          "保持当前的学习节奏",
          "多参与课堂讨论"
        ],
        confidence: 94.5,
        status: "completed"
      }
    ];

    // 生成AI建议结果
    const mockAISuggestionResults: AISuggestionResult[] = [
      {
        id: "1",
        timestamp: new Date(Date.now() - 2 * 60 * 60 * 1000),
        suggestionType: "study_plan",
        title: "个性化学习计划",
        description: "基于你的学习情况，制定针对性的学习计划",
        suggestions: [
          "每天安排30分钟英语听说练习",
          "每周至少3次算法练习题",
          "保持Python编程的练习频率",
          "定期复习数学基础知识"
        ],
        priority: "high",
        estimatedTime: "2小时/天",
        difficulty: 3,
        status: "completed"
      }
    ];

    setCourseScores(mockCourseScores);
    setLearningStatus(mockLearningStatus);
    setKnowledgePoints(mockKnowledgePoints);
    setAiAnalysisResults(mockAIAnalysisResults);
    setAiSuggestionResults(mockAISuggestionResults);
  };

  // 生成新的AI分析结果
  const generateNewAIAnalysis = async () => {
    setAnalyzing(true);
    message.loading("AI正在深度分析学习数据...", 0);

    // 模拟AI分析过程
    await new Promise(resolve => setTimeout(resolve, 4000));

    const analysisTemplates = {
      overall: {
        summaries: [
          "基于你本学期的学习数据分析，整体表现稳定且积极向上。在技术类课程中表现尤为突出，特别是在编程实践方面展现了较强的逻辑思维和问题解决能力。建议继续保持当前的学习节奏，同时在某些基础理论课程上加强理解和记忆。",
          "通过综合分析你的学习轨迹，发现你具有很好的学习态度和积极性。在实践性课程中表现优秀，但在某些需要深度思考的理论课程上还有提升空间。建议在保持现有优势的基础上，加强对基础知识的巩固。",
          "你的学习数据表明，编程能力较强，代码逻辑清晰，实践动手能力突出。在理论课程方面，虽然基础扎实，但需要更多的时间和精力来深入理解复杂概念。建议平衡理论与实践的学习时间分配。",
          "从出勤率、作业完成度和考试成绩来看，你的学习态度非常认真。在技术实践方面表现优秀，但在某些需要长期积累的学科上还需要持续努力。建议增加实践练习，同时保持对理论知识的系统性学习。"
        ],
        findings: [
          "Python编程课程表现优秀，在班级排名中位居前列，代码质量和逻辑思维得到教师高度认可",
          "数学基础扎实，计算能力较强，但在应用题和综合题方面还有提升空间",
          "英语听说能力相对薄弱，虽然阅读和写作能力良好，但口语表达需要加强练习",
          "算法设计能力有待提升，在复杂问题分析和解决方面需要更多训练",
          "学习时间管理较为合理，但碎片化时间利用效率可以进一步提高",
          "团队协作能力良好，在小组项目中表现积极，沟通能力较强"
        ],
        recommendations: [
          "建议每天安排30-45分钟的英语听说练习，可以使用英语学习APP或参加英语角活动",
          "加强算法设计练习，每周至少完成3-5道中等难度的算法题，提升问题分析能力",
          "保持Python编程的练习频率，尝试参与开源项目或编程竞赛，提升实战经验",
          "多参与课堂讨论和互动，主动提问和分享观点，提升表达能力和理解深度",
          "制定详细的学习计划，合理分配各科目的学习时间，确保全面发展",
          "利用周末时间进行知识复习和总结，建立知识体系，提高学习效率"
        ]
      },
      course_specific: {
        "高等数学(一)": {
          summaries: [
            "在高等数学课程中，你的成绩呈现下降趋势，从B+降至B-。虽然出勤率较高（96%），但作业和考试成绩都不理想。微积分概念理解不够深入，解题速度和准确性都有待提升。建议加强基础练习，提高数学思维能力。",
            "从数学学习数据来看，你在基础计算方面表现尚可，但在综合应用题和证明题方面存在明显不足。作业完成率93%，考试平均分79.8分，排名第22位，需要系统性的改进。",
            "你的数学学习态度认真，但学习方法可能存在问题。建议重新审视学习策略，加强概念理解和应用能力训练。"
          ],
          findings: [
            "微积分基本概念理解不够深入，需要加强基础训练",
            "计算准确性一般，在复杂运算中错误率较高",
            "解题速度较慢，在考试中经常时间不够",
            "应用题解决能力薄弱，数学建模思维需要加强",
            "对数学概念的记忆不够牢固，理解深度有限",
            "在证明题方面表现较差，逻辑推理能力需要提升"
          ],
          recommendations: [
            "每天安排1-2小时数学练习，重点练习微积分基础题目",
            "参加数学辅导班或找同学组成学习小组，互相讨论解题思路",
            "多做应用题和证明题，提高数学建模和逻辑推理能力",
            "利用数学软件如Mathematica辅助学习，加深对抽象概念的理解",
            "建立错题本，总结常见错误和解题方法",
            "定期复习基础知识，确保概念理解准确"
          ]
        },
        "大学英语(一)": {
          summaries: [
            "在英语课程中，你的成绩表现一般，总评84.4分，排名第35位。虽然出勤率88%，但听说能力明显不足，这是影响整体成绩的主要原因。建议重点加强听说训练，提高英语实际应用能力。",
            "从英语学习数据来看，你在阅读和写作方面表现尚可，但在听力和口语方面存在明显短板。作业完成率90%，考试平均分83.2分，需要系统性的听说能力提升。",
            "你的英语学习基础一般，需要重新制定学习计划，重点突破听说难关。"
          ],
          findings: [
            "英语词汇量积累不足，影响听力和阅读理解",
            "语法基础一般，在写作中错误较多",
            "听力理解能力薄弱，在快速听力中经常听不懂",
            "口语表达困难，缺乏自信和流利度",
            "阅读理解能力一般，需要提高阅读速度",
            "写作表达能力有限，语法错误较多"
          ],
          recommendations: [
            "每天安排30-45分钟英语听说练习，使用英语学习APP如Duolingo",
            "参加英语角或找外教一对一练习口语，提高口语流利度",
            "多听英语新闻、播客，提高听力理解能力",
            "背诵常用英语短语和句型，提高口语表达",
            "利用英语学习软件如BBC Learning English进行系统学习",
            "观看英语电影或电视剧，提高语感和听力理解"
          ]
        },
        "Python程序设计": {
          summaries: [
            "在Python编程课程中，你的表现非常突出，编程能力较强，逻辑思维清晰。代码质量高，能够独立解决较复杂的编程问题。学习积极性很高，建议继续深入学习，尝试更高级的编程概念和项目开发。",
            "你的编程基础扎实，对Python语法和基本概念掌握得很好。实践能力强，能够将理论知识应用到实际编程中。代码风格良好，注释清晰，体现了良好的编程习惯。",
            "从编程学习数据来看，你具有很好的问题解决能力和学习能力。能够快速掌握新的编程概念，并在实践中灵活运用。建议继续提升编程技能，尝试参与实际项目开发。"
          ],
          findings: [
            "Python基础语法掌握扎实，能够熟练运用各种数据类型和结构",
            "代码逻辑清晰，能够设计合理的算法解决编程问题",
            "问题解决能力强，能够独立分析和解决编程难题",
            "学习效率高，能够快速掌握新的编程概念和技术",
            "代码风格良好，注释清晰，体现了良好的编程习惯",
            "在面向对象编程方面理解深入，能够设计合理的类结构"
          ],
          recommendations: [
            "学习更高级的Python概念，如装饰器、生成器、异步编程等",
            "参与编程竞赛或在线编程平台，提升算法和数据结构能力",
            "尝试开发完整的项目，如Web应用、数据分析项目等",
            "学习其他编程语言，如Java、C++等，拓展技术栈",
            "参与开源项目，学习优秀的代码风格和设计模式",
            "关注Python生态圈的新技术和框架，保持技术更新"
          ]
        },
        "数据结构与算法": {
          summaries: [
            "在数据结构与算法课程中，你的成绩表现较差，总评77.1分，排名第28位。虽然出勤率92%，但作业完成率89%，考试平均分75.3分，说明在算法理解和实现方面存在较大困难。建议加强基础训练，提高算法思维能力。",
            "从算法学习数据来看，你在基础数据结构理解方面表现尚可，但在复杂算法设计和优化方面存在明显不足。需要系统性的算法训练和思维培养。",
            "你的算法学习基础薄弱，需要重新建立学习体系，从基础开始逐步提升。"
          ],
          findings: [
            "基础数据结构（数组、链表、栈、队列）掌握一般",
            "复杂数据结构（树、图、堆）理解不够深入",
            "算法设计能力薄弱，缺乏系统性思维",
            "代码实现能力一般，经常出现逻辑错误",
            "时间复杂度分析能力不足，无法正确评估算法效率",
            "动态规划、贪心等高级算法理解困难"
          ],
          recommendations: [
            "每天安排1-2小时算法练习，从基础题目开始逐步提升",
            "使用LeetCode、牛客网等平台进行系统性算法训练",
            "重点掌握基础数据结构，确保理解透彻后再学习复杂算法",
            "多做算法题，培养算法思维和问题解决能力",
            "学习算法可视化工具，加深对算法过程的理解",
            "参加算法竞赛或编程训练营，提升实战能力"
          ]
        },
        "大学物理(一)": {
          summaries: [
            "在大学物理课程中，你的成绩表现较好，总评85.7分，排名第16位。出勤率94%，作业完成率93%，考试平均分84.1分，说明你对物理概念理解较好，学习态度认真。建议继续保持当前学习节奏。",
            "从物理学习数据来看，你在力学和热学方面表现稳定，但在某些抽象概念理解方面还有提升空间。整体学习效果良好，有上升趋势。",
            "你的物理学习基础扎实，建议继续保持并尝试挑战更高难度的内容。"
          ],
          findings: [
            "力学基础扎实，能够正确运用牛顿定律和能量守恒",
            "热学概念理解较好，能够解决基本的热学问题",
            "数学工具运用能力较强，能够进行基本的物理计算",
            "实验操作能力一般，需要加强实验技能训练",
            "物理建模能力有待提升，在复杂问题分析方面需要加强",
            "对物理概念的记忆较为牢固，但理解深度可以进一步加深"
          ],
          recommendations: [
            "继续保持当前的学习节奏和方法，巩固已掌握的知识",
            "多参与物理实验，提高实验操作和数据分析能力",
            "尝试解决更复杂的物理问题，提升物理建模能力",
            "阅读物理科普书籍，加深对物理概念的理解",
            "参加物理讨论小组，与同学交流学习心得",
            "关注物理前沿发展，培养对物理学的兴趣"
          ]
        },
        "线性代数": {
          summaries: [
            "在线性代数课程中，你的成绩表现一般，总评79.2分，排名第31位。虽然出勤率90%，但作业完成率92%，考试平均分77.8分，说明在矩阵运算和向量空间理解方面存在困难。建议加强基础训练。",
            "从线性代数学习数据来看，你在基础运算方面表现尚可，但在抽象概念理解方面存在明显不足。需要重新审视学习方法，加强概念理解。",
            "你的线性代数学习基础一般，需要系统性的改进和提升。"
          ],
          findings: [
            "矩阵基本运算掌握一般，在复杂运算中容易出错",
            "向量空间概念理解不够深入，抽象思维能力需要加强",
            "线性变换理解困难，几何直观性不足",
            "特征值和特征向量概念模糊，应用能力有限",
            "线性方程组求解能力一般，需要提高计算准确性",
            "对线性代数在计算机科学中的应用了解有限"
          ],
          recommendations: [
            "每天安排1小时线性代数练习，重点练习矩阵运算",
            "使用几何直观理解线性变换和向量空间概念",
            "多做练习题，提高计算准确性和速度",
            "学习线性代数在计算机图形学、机器学习中的应用",
            "参加线性代数辅导班或找同学组成学习小组",
            "利用在线资源如3Blue1Brown的视频加深理解"
          ]
        }
      }
    };

    const analysisType = selectedCourse === "all" ? "overall" : "course_specific";
    let template;
    
    if (analysisType === "overall") {
      template = analysisTemplates.overall;
    } else {
      template = analysisTemplates.course_specific[selectedCourse as keyof typeof analysisTemplates.course_specific] || analysisTemplates.overall;
    }

    const summary = template.summaries[Math.floor(Math.random() * template.summaries.length)];
    const findings = template.findings.slice(0, Math.floor(Math.random() * 3) + 3);
    const recommendations = template.recommendations.slice(0, Math.floor(Math.random() * 3) + 3);

    const newAnalysis: AIAnalysisResult = {
      id: Date.now().toString(),
      timestamp: new Date(),
      courseId: selectedCourse === "all" ? undefined : selectedCourse,
      analysisType: analysisType as any,
      summary,
      keyFindings: findings,
      recommendations,
      confidence: Math.floor(Math.random() * 15) + 85,
      status: "completed"
    };

    // 只保留最新的一个结果
    setAiAnalysisResults([newAnalysis]);
    setAnalyzing(false);
    message.destroy();
    message.success("AI深度分析完成！");
  };

  // 生成新的AI建议结果
  const generateNewAISuggestion = async () => {
    setSuggesting(true);
    message.loading("AI正在生成个性化学习建议...", 0);

    // 模拟AI建议生成过程
    await new Promise(resolve => setTimeout(resolve, 3500));

    const suggestionTemplates = {
      study_plan: {
        titles: [
          "个性化学习计划制定",
          "高效学习策略优化",
          "智能时间管理方案",
          "阶段性学习目标规划",
          "深度学习路径设计"
        ],
        descriptions: [
          "基于你的学习数据和学习习惯，AI为你量身定制个性化的学习计划，包含具体的时间安排、学习方法和进度跟踪",
          "结合你的学习特点和课程要求，提供科学高效的学习策略，帮助你最大化学习效果和效率",
          "根据你的日常作息和学习规律，设计智能化的时间管理方案，确保学习、休息和娱乐的平衡",
          "制定明确的阶段性学习目标，包含短期、中期和长期目标，帮助你建立清晰的学习方向",
          "设计系统性的深度学习路径，从基础到进阶，循序渐进地提升你的学习能力和知识水平"
        ],
        suggestions: [
          "每天安排30-45分钟的英语听说练习，使用英语学习APP如Duolingo或参加线上英语角",
          "每周至少完成3-5道中等难度的算法题，使用LeetCode或牛客网等平台进行练习",
          "保持Python编程的每日练习频率，尝试参与开源项目或编程竞赛提升实战经验",
          "每周末安排2-3小时进行数学知识复习和总结，建立完整的知识体系",
          "制定详细的每日学习计划表，包含具体的学习任务、时间分配和完成标准",
          "利用碎片化时间（如通勤、排队等）进行单词记忆或知识点复习",
          "建立学习小组，与同学互相监督和讨论，提高学习积极性和效果",
          "使用番茄工作法（25分钟专注学习+5分钟休息）提高学习效率和专注度"
        ]
      },
      skill_improvement: {
        titles: [
          "专业技能提升方案",
          "综合能力发展计划",
          "核心竞争力培养",
          "跨学科能力拓展",
          "创新思维培养计划"
        ],
        descriptions: [
          "针对你的专业领域和职业发展方向，制定系统性的技能提升方案，包含技术技能和软技能的全面发展",
          "基于你的学习特点和兴趣，设计综合能力发展计划，提升沟通、协作、领导力等多方面能力",
          "识别和培养你的核心竞争力，在专业领域建立独特的优势和特长",
          "鼓励跨学科学习和能力拓展，培养多元化的知识结构和思维方式",
          "培养创新思维和解决问题的能力，提升在复杂环境中的适应性和创造力"
        ],
        suggestions: [
          "参加编程竞赛如ACM、蓝桥杯等，提升算法设计和问题解决能力",
          "加入英语角或英语俱乐部，定期参与口语练习和文化交流活动",
          "参与实际项目开发，如校园管理系统、数据分析项目等，积累实战经验",
          "学习新技术如机器学习、大数据分析等，扩展技术栈和知识面",
          "参加学术讲座、技术分享会等，了解前沿技术和行业动态",
          "培养团队协作能力，主动承担团队项目中的不同角色和责任",
          "学习设计思维和创新方法，提升创造性解决问题的能力",
          "建立个人技术博客或GitHub项目，展示个人能力和学习成果"
        ]
      },
      time_management: {
        titles: [
          "智能时间管理优化",
          "学习效率提升方案",
          "科学作息时间调整",
          "学习节奏智能优化",
          "时间投资回报最大化"
        ],
        descriptions: [
          "运用时间管理理论和方法，结合你的学习规律，设计智能化的时间管理方案",
          "通过科学的方法和工具，全面提升你的学习效率和效果，实现事半功倍",
          "根据你的生理节律和学习习惯，调整作息时间，保持最佳的学习状态",
          "优化学习节奏，合理安排学习强度，避免过度疲劳和学习倦怠",
          "将时间视为投资，合理分配时间资源，最大化学习回报和成长效果"
        ],
        suggestions: [
          "制定详细的时间计划表，使用时间管理工具如Forest或番茄钟APP",
          "使用番茄工作法提高学习效率，25分钟专注学习+5分钟休息循环",
          "合理安排休息时间，每学习1小时休息10-15分钟，保持精力充沛",
          "避免熬夜，保持充足的睡眠（7-8小时），确保大脑充分休息和恢复",
          "利用黄金时间（上午9-11点，下午2-4点）学习重要和困难的内容",
          "减少无效时间浪费，如过度刷手机、无目的浏览网页等",
          "建立学习仪式感，如固定的学习环境和时间，提高学习专注度",
          "定期评估时间使用效果，调整时间分配策略，持续优化学习效率"
        ]
      },
      exam_preparation: {
        titles: [
          "科学考试准备策略",
          "系统复习计划制定",
          "应试技巧全面提升",
          "考试心态调整方案",
          "压力管理优化策略"
        ],
        descriptions: [
          "基于考试类型和你的学习情况，制定科学的考试准备策略，确保全面有效的复习",
          "制定系统性的复习计划，合理分配复习时间和重点，确保知识点的全面掌握",
          "全面提升应试技巧，包括答题技巧、时间管理、心理调节等方面",
          "调整考试心态，建立积极健康的考试心理，避免焦虑和紧张影响发挥",
          "优化压力管理策略，学会在压力下保持最佳的学习和考试状态"
        ],
        suggestions: [
          "制定详细的复习计划，按知识点重要性和掌握程度分配复习时间",
          "重点复习薄弱环节，针对性地进行强化训练和练习",
          "多做模拟试题和历年真题，熟悉考试题型和答题技巧",
          "掌握科学的答题技巧，如先易后难、合理分配时间等",
          "保持积极的学习心态，建立自信心，避免过度焦虑和紧张",
          "合理安排复习时间，避免临时抱佛脚，确保充足的复习时间",
          "建立错题本，总结常见错误和解题思路，避免重复犯错",
          "进行模拟考试训练，适应考试环境和时间压力"
        ]
      }
    };

    const suggestionTypes = ["study_plan", "skill_improvement", "time_management", "exam_preparation"];
    const suggestionType = suggestionTypes[Math.floor(Math.random() * suggestionTypes.length)];
    const template = suggestionTemplates[suggestionType as keyof typeof suggestionTemplates];

    const title = template.titles[Math.floor(Math.random() * template.titles.length)];
    const description = template.descriptions[Math.floor(Math.random() * template.descriptions.length)];
    const suggestions = template.suggestions.slice(0, Math.floor(Math.random() * 3) + 5);

    const newSuggestion: AISuggestionResult = {
      id: Date.now().toString(),
      timestamp: new Date(),
      courseId: selectedCourse === "all" ? undefined : selectedCourse,
      suggestionType: suggestionType as any,
      title,
      description,
      suggestions,
      priority: ["high", "medium", "low"][Math.floor(Math.random() * 3)] as any,
      estimatedTime: `${Math.floor(Math.random() * 2) + 1}-${Math.floor(Math.random() * 2) + 3}小时/天`,
      difficulty: Math.floor(Math.random() * 3) + 1,
      status: "completed"
    };

    // 只保留最新的一个结果
    setAiSuggestionResults([newSuggestion]);
    setSuggesting(false);
    message.destroy();
    message.success("AI个性化建议生成完成！");
  };

  // 加载数据
  const loadData = async () => {
    setLoading(true);
    try {
      // 模拟API调用
      await new Promise(resolve => setTimeout(resolve, 1000));
      generateMockData();
      // 清空AI分析结果，需要用户手动获取
      setAiAnalysisResults([]);
      setAiSuggestionResults([]);
    } catch (error) {
      message.error("加载数据失败");
    } finally {
      setLoading(false);
    }
  };

  useEffect(() => {
    loadData();
  }, []);

  // 渲染学习状态指标
  const renderLearningMetrics = () => (
    <Row gutter={[16, 16]}>
      <Col xs={24} sm={12} lg={6}>
        <MetricCard>
          <div className="metric-content">
            <div className="metric-icon" style={{ color: "#1890ff" }}>
              <BookOutlined />
            </div>
            <div className="metric-value">{learningStatus.totalCourses}</div>
            <div className="metric-label">总课程数</div>
            <div className="metric-trend">
              <span style={{ color: "#52c41a" }}>本学期</span>
            </div>
          </div>
        </MetricCard>
      </Col>
      <Col xs={24} sm={12} lg={6}>
        <MetricCard>
          <div className="metric-content">
            <div className="metric-icon" style={{ color: "#52c41a" }}>
              <TrophyOutlined />
            </div>
            <div className="metric-value">{learningStatus.averageScore}</div>
            <div className="metric-label">平均分</div>
            <div className="metric-trend">
              <RiseOutlined style={{ color: "#52c41a" }} />
              <span style={{ color: "#52c41a" }}>+{learningStatus.improvement}%</span>
            </div>
          </div>
        </MetricCard>
      </Col>
      <Col xs={24} sm={12} lg={6}>
        <MetricCard>
          <div className="metric-content">
            <div className="metric-icon" style={{ color: "#faad14" }}>
              <ClockCircleOutlined />
            </div>
            <div className="metric-value">{learningStatus.attendanceRate}%</div>
            <div className="metric-label">出勤率</div>
            <div className="metric-trend">
              <CheckCircleOutlined style={{ color: "#52c41a" }} />
              <span style={{ color: "#52c41a" }}>优秀</span>
            </div>
          </div>
        </MetricCard>
      </Col>
      <Col xs={24} sm={12} lg={6}>
        <MetricCard>
          <div className="metric-content">
            <div className="metric-icon" style={{ color: "#722ed1" }}>
              <StarOutlined />
            </div>
            <div className="metric-value">{learningStatus.ranking}</div>
            <div className="metric-label">班级排名</div>
            <div className="metric-trend">
              <RiseOutlined style={{ color: "#52c41a" }} />
              <span style={{ color: "#52c41a" }}>上升</span>
            </div>
          </div>
        </MetricCard>
      </Col>
    </Row>
  );

  // 渲染课程成绩表格
  const renderCourseScoresTable = () => {
    const columns = [
      {
        title: "课程名称",
        dataIndex: "courseName",
        key: "courseName",
        render: (text: string, record: CourseScore) => (
          <Space>
            <BookIcon style={{ color: "#1890ff" }} />
            <div>
              <div style={{ fontWeight: 500 }}>{text}</div>
              <Text type="secondary" style={{ fontSize: "12px" }}>
                {record.teacherName} · {record.credit}学分
              </Text>
            </div>
          </Space>
        ),
      },
      {
        title: "出勤率",
        dataIndex: "attendance",
        key: "attendance",
        render: (attendance: number) => (
          <Progress
            percent={attendance}
            size="small"
            status={attendance >= 90 ? "success" : attendance >= 80 ? "normal" : "exception"}
            showInfo={false}
          />
        ),
      },
      {
        title: "作业情况",
        key: "homework",
        render: (_: any, record: CourseScore) => (
          <div>
            <div>{record.homework.submitted}/{record.homework.total}</div>
            <Text type="secondary" style={{ fontSize: "12px" }}>
              平均分: {record.homework.averageScore}
            </Text>
          </div>
        ),
      },
      {
        title: "考试情况",
        key: "exams",
        render: (_: any, record: CourseScore) => (
          <div>
            <div>{record.exams.completed}/{record.exams.total}</div>
            <Text type="secondary" style={{ fontSize: "12px" }}>
              平均分: {record.exams.averageScore}
            </Text>
          </div>
        ),
      },
      {
        title: "总评成绩",
        dataIndex: "overallScore",
        key: "overallScore",
        render: (score: number, record: CourseScore) => (
          <Space direction="vertical" size="small">
            <div style={{ fontWeight: 500, fontSize: "16px" }}>{score}</div>
            <TrendTag color={record.trend === "up" ? "green" : record.trend === "down" ? "red" : "default"}>
              {record.trend === "up" ? "上升" : record.trend === "down" ? "下降" : "稳定"}
            </TrendTag>
          </Space>
        ),
      },
      {
        title: "等级",
        dataIndex: "grade",
        key: "grade",
        render: (grade: string) => {
          const colorMap: { [key: string]: string } = {
            "A": "green",
            "A-": "green",
            "B+": "blue",
            "B": "blue",
            "B-": "orange",
            "C+": "orange",
            "C": "red",
            "C-": "red",
            "D": "red",
            "F": "red",
          };
          return <Tag color={colorMap[grade] || "default"}>{grade}</Tag>;
        },
      },
    ];

    return (
      <Table
        columns={columns}
        dataSource={courseScores}
        rowKey="id"
        pagination={false}
        size="small"
      />
    );
  };

  // 渲染知识点掌握雷达图
  const renderKnowledgeRadarChart = () => (
    <ResponsiveContainer width="100%" height={300}>
      <RadarChart data={knowledgePoints}>
        <PolarGrid />
        <PolarAngleAxis dataKey="name" />
        <PolarRadiusAxis angle={90} domain={[0, 100]} />
        <Radar
          name="掌握度"
          dataKey="mastery"
          stroke="#1890ff"
          fill="#1890ff"
          fillOpacity={0.3}
        />
        <RechartsTooltip />
      </RadarChart>
    </ResponsiveContainer>
  );

  // 渲染AI分析结果
  const renderAIAnalysis = () => {
    return (
      <div>
        <div style={{ marginBottom: 16, textAlign: "center" }}>
          <Button
            type="primary"
            icon={analyzing ? <LoadingOutlined /> : <RobotOutlined />}
            loading={analyzing}
            onClick={generateNewAIAnalysis}
            size="large"
            style={{ marginRight: 16 }}
          >
            {analyzing ? "AI分析中..." : "获取AI分析"}
          </Button>
          <Button
            icon={<SyncOutlined />}
            onClick={generateNewAIAnalysis}
            disabled={analyzing}
          >
            重新生成
          </Button>
        </div>

        <Row gutter={[16, 16]}>
          {aiAnalysisResults.map((analysis) => (
            <Col xs={24} lg={12} key={analysis.id}>
              <AIAnalysisCard
                title={
                  <Space>
                    <RobotOutlined style={{ color: "#52c41a" }} />
                    {analysis.analysisType === "overall" ? "整体学习分析" : "课程专项分析"}
                    <Tag color="blue">{analysis.confidence}% 置信度</Tag>
                  </Space>
                }
                extra={
                  <Text type="secondary" style={{ fontSize: "12px" }}>
                    {dayjs(analysis.timestamp).format("MM-DD HH:mm")}
                  </Text>
                }
              >
                <Paragraph strong style={{ marginBottom: 16 }}>
                  {analysis.summary}
                </Paragraph>
                
                <div style={{ marginBottom: 16 }}>
                  <Text strong>关键发现：</Text>
                  <ul style={{ marginTop: 8 }}>
                    {analysis.keyFindings.map((finding, index) => (
                      <li key={index}>{finding}</li>
                    ))}
                  </ul>
                </div>

                <div>
                  <Text strong>建议措施：</Text>
                  <ul style={{ marginTop: 8 }}>
                    {analysis.recommendations.map((rec, index) => (
                      <li key={index}>{rec}</li>
                    ))}
                  </ul>
                </div>
              </AIAnalysisCard>
            </Col>
          ))}
        </Row>

        {aiAnalysisResults.length === 0 && (
          <Empty
            description={
              <div>
                <div style={{ marginBottom: 8 }}>点击上方按钮获取AI深度分析</div>
                <div style={{ fontSize: "12px", color: "#999" }}>
                  AI将基于你的学习数据提供详细的学习分析和改进建议
                </div>
              </div>
            }
            image={Empty.PRESENTED_IMAGE_SIMPLE}
          />
        )}
      </div>
    );
  };

  // 渲染AI建议结果
  const renderAISuggestions = () => {
    return (
      <div>
        <div style={{ marginBottom: 16, textAlign: "center" }}>
          <Button
            type="primary"
            icon={suggesting ? <LoadingOutlined /> : <BulbOutlined />}
            loading={suggesting}
            onClick={generateNewAISuggestion}
            size="large"
            style={{ marginRight: 16 }}
          >
            {suggesting ? "AI建议生成中..." : "获取AI建议"}
          </Button>
          <Button
            icon={<SyncOutlined />}
            onClick={generateNewAISuggestion}
            disabled={suggesting}
          >
            重新生成
          </Button>
        </div>

        <Row gutter={[16, 16]}>
          {aiSuggestionResults.map((suggestion) => (
            <Col xs={24} lg={12} key={suggestion.id}>
              <AISuggestionCard
                title={
                  <Space>
                    <BulbOutlined style={{ color: "#fa8c16" }} />
                    {suggestion.title}
                    <Tag color={suggestion.priority === "high" ? "red" : suggestion.priority === "medium" ? "orange" : "green"}>
                      {suggestion.priority === "high" ? "高优先级" : suggestion.priority === "medium" ? "中优先级" : "低优先级"}
                    </Tag>
                  </Space>
                }
                extra={
                  <Space direction="vertical" size="small" align="end">
                    <Text type="secondary" style={{ fontSize: "12px" }}>
                      {dayjs(suggestion.timestamp).format("MM-DD HH:mm")}
                    </Text>
                    <div>
                      <Text type="secondary" style={{ fontSize: "12px" }}>
                        难度: <Rate disabled defaultValue={suggestion.difficulty} />
                      </Text>
                    </div>
                  </Space>
                }
              >
                <Paragraph style={{ marginBottom: 16 }}>
                  {suggestion.description}
                </Paragraph>
                
                <div style={{ marginBottom: 16 }}>
                  <Text strong>具体建议：</Text>
                  <ul style={{ marginTop: 8 }}>
                    {suggestion.suggestions.map((sug, index) => (
                      <li key={index}>{sug}</li>
                    ))}
                  </ul>
                </div>

                <div>
                  <Text strong>预计时间：</Text>
                  <Text type="secondary" style={{ marginLeft: 8 }}>
                    {suggestion.estimatedTime}
                  </Text>
                </div>
              </AISuggestionCard>
            </Col>
          ))}
        </Row>

        {aiSuggestionResults.length === 0 && (
          <Empty
            description={
              <div>
                <div style={{ marginBottom: 8 }}>点击上方按钮获取AI个性化建议</div>
                <div style={{ fontSize: "12px", color: "#999" }}>
                  AI将为你量身定制学习计划、技能提升和时间管理建议
                </div>
              </div>
            }
            image={Empty.PRESENTED_IMAGE_SIMPLE}
          />
        )}
      </div>
    );
  };

  if (loading && courseScores.length === 0) {
    return (
      <div style={{ textAlign: "center", padding: "100px 0" }}>
        <Spin size="large" />
        <div style={{ marginTop: 16 }}>正在加载学习分析数据...</div>
      </div>
    );
  }

  return (
    <AnalysisContainer>
      {/* 页面头部 */}
      <div style={{ marginBottom: 24 }}>
        <Row justify="space-between" align="middle">
          <Col>
            <Title level={3} style={{ margin: 0 }}>
              <BarChartOutlined /> 学习分析中心
            </Title>
            <Text type="secondary">
              欢迎回来，{user?.name}！今天是 {dayjs().format("YYYY年MM月DD日")}
            </Text>
          </Col>
          <Col>
            <Space>
              <Select
                value={selectedCourse}
                onChange={setSelectedCourse}
                style={{ width: 200 }}
                placeholder="选择课程"
              >
                <Option value="all">全部课程</Option>
                {courseScores.map(course => (
                  <Option key={course.id} value={course.id}>{course.courseName}</Option>
                ))}
              </Select>
              <Button icon={<ReloadOutlined />} onClick={loadData}>
                刷新数据
              </Button>
            </Space>
          </Col>
        </Row>
      </div>

      {/* 学习状态指标 */}
      {renderLearningMetrics()}

      {/* 主要内容 */}
      <Tabs defaultActiveKey="overview" style={{ marginTop: 24 }}>
        <TabPane tab="学习概览" key="overview">
          <Row gutter={[16, 16]}>
            <Col xs={24} lg={16}>
              <StyledCard title="课程成绩详情" extra={<EyeOutlined />}>
                {renderCourseScoresTable()}
              </StyledCard>
            </Col>
            <Col xs={24} lg={8}>
              <StyledCard title="知识点掌握情况" extra={<PieChartOutlined />}>
                {renderKnowledgeRadarChart()}
              </StyledCard>
            </Col>
            <Col xs={24}>
              <StyledCard title="学习进度统计" extra={<LineChartOutlined />}>
                <Row gutter={[16, 16]}>
                  <Col span={6}>
                    <Statistic
                      title="作业完成率"
                      value={learningStatus.homeworkCompletionRate}
                      suffix="%"
                      valueStyle={{ color: "#52c41a" }}
                    />
                  </Col>
                  <Col span={6}>
                    <Statistic
                      title="考试通过率"
                      value={learningStatus.examPassRate}
                      suffix="%"
                      valueStyle={{ color: "#1890ff" }}
                    />
                  </Col>
                  <Col span={6}>
                    <Statistic
                      title="周学习时长"
                      value={learningStatus.studyTime}
                      suffix="小时"
                      valueStyle={{ color: "#faad14" }}
                    />
                  </Col>
                  <Col span={6}>
                    <Statistic
                      title="班级排名"
                      value={learningStatus.ranking}
                      suffix="/50"
                      valueStyle={{ color: "#722ed1" }}
                    />
                  </Col>
                </Row>
              </StyledCard>
            </Col>
          </Row>
        </TabPane>

        <TabPane tab="AI学习分析" key="ai-analysis">
          {renderAIAnalysis()}
        </TabPane>

        <TabPane tab="AI学习建议" key="ai-suggestions">
          {renderAISuggestions()}
        </TabPane>
      </Tabs>
    </AnalysisContainer>
  );
};

export default StudentLearningAnalysis; 